TypeScript Geologija: Implementacija tipov znanosti o Zemlji za globalno občinstvo

            
// Enum for broad rock categories
export enum RockCategory {
  Igneous = "Igneous",
  Sedimentary = "Sedimentary",
  Metamorphic = "Metamorphic",
  Unclassified = "Unclassified"
}

// Interface for a specific mineral composition
export interface MineralComposition {
  mineral: string; // e.g., "Quartz", "Feldspar", "Mica"
  percentage: number; // Percentage by volume or weight
}

// Interface for a general lithology descriptor
export interface LithologyDescriptor {
  name: string; // e.g., "Granite", "Sandstone", "Schist"
  category: RockCategory;
  description?: string; // Optional detailed description
  primaryMinerals?: MineralComposition[];
  secondaryMinerals?: MineralComposition[];
  grainSize?: "Fine" | "Medium" | "Coarse"; // e.g., for sedimentary rocks
  porosity?: number; // Percentage, for reservoir rocks
  permeability?: number; // e.g., in mD (millidarcy)
}

// Example Usage:
const graniteLithology: LithologyDescriptor = {
  name: "Biotite Granite",
  category: RockCategory.Igneous,
  description: "A coarse-grained igneous rock rich in quartz, feldspar, and biotite mica.",
  primaryMinerals: [
    { mineral: "Quartz", percentage: 30 },
    { mineral: "Orthoclase Feldspar", percentage: 40 },
    { mineral: "Plagioclase Feldspar", percentage: 15 }
  ],
  secondaryMinerals: [
    { mineral: "Biotite", percentage: 10 },
    { mineral: "Muscovite", percentage: 5 }
  ],
  grainSize: "Coarse"
};

            

              
                Copy
              
            
          

            
// Enum for crystal systems
export enum CrystalSystem {
  Cubic = "Cubic",
  Tetragonal = "Tetragonal",
  Orthorhombic = "Orthorhombic",
  Monoclinic = "Monoclinic",
  Triclinic = "Triclinic",
  Hexagonal = "Hexagonal",
  Trigonal = "Trigonal"
}

// Interface for a specific mineral
export interface Mineral {
  name: string; // e.g., "Quartz", "Calcite", "Pyrite"
  chemicalFormula: string; // e.g., "SiO2", "CaCO3", "FeS2"
  mohsHardness: number;
  density: number; // g/cm³
  color?: string[]; // Array of common colors
  streak?: string;
  luster?: "Vitreous" | "Metallic" | "Dull" | "Resinous";
  crystalSystem: CrystalSystem;
  formationEnvironment?: string[]; // e.g., "Hydrothermal", "Igneous", "Metamorphic"
}

// Example Usage:
const quartzMineral: Mineral = {
  name: "Quartz",
  chemicalFormula: "SiO2",
  mohsHardness: 7,
  density: 2.65,
  color: ["Colorless", "White", "Pink", "Purple", "Brown", "Black"],
  luster: "Vitreous",
  crystalSystem: CrystalSystem.Hexagonal,
  formationEnvironment: ["Igneous", "Metamorphic", "Sedimentary"]
};

            

              
                Copy
              
            
          

            
// Enum for fault types
export enum FaultType {
  Normal = "Normal",
  Reverse = "Reverse",
  Thrust = "Thrust",
  StrikeSlip = "Strike-Slip",
  ObliqueSlip = "Oblique-Slip",
  Unknown = "Unknown"
}

// Interface for a fault segment
export interface FaultSegment {
  id: string; // Unique identifier
  name?: string; // Optional name (e.g., "San Andreas Fault")
  type: FaultType;
  dipAngle?: number; // Degrees from horizontal
  dipDirection?: number; // Degrees from North (0-360)
  strike?: number; // Degrees from North (0-360)
  rake?: number; // Angle of slip on the fault plane (degrees)
  length?: number; // Kilometers
  displacement?: number; // Meters or kilometers
  associatedStructures?: string[]; // e.g., "drag folds", "shatter zones"
}

// Interface for a fold
export interface Fold {
  id: string;
  name?: string;
  axisTrend?: number; // Degrees from North
  axisPlunge?: number; // Degrees from horizontal
  hingeLine?: string;
  limbs?: Array<{ side: "Upward" | "Downward" | "Left" | "Right", dipAngle?: number, dipDirection?: number }>;
  foldType?: "Anticline" | "Syncline" | "Monocline" | "Chevron" | "Box" | "Concentric";
}

// Example Usage:
const majorFault: FaultSegment = {
  id: "FA-101",
  name: "East African Rift Fault",
  type: FaultType.Normal,
  dipAngle: 60,
  dipDirection: 90, // East
  strike: 0,
  length: 1000,
  displacement: 5000 // meters
};

            

              
                Copy
              
            
          

            
// Enum for dating methods
export enum DatingMethod {
  Radiometric = "Radiometric",
  Paleomagnetic = "Paleomagnetic",
  Biostratigraphic = "Biostratigraphic",
  Archaeomagnetic = "Archaeomagnetic"
}

// Interface for a radiometric dating result
export interface RadiometricDate {
  method: DatingMethod.Radiometric;
  isotopeSystem: string; // e.g., "U-Pb", "K-Ar", "Ar-Ar", "Rb-Sr"
  age: number; // Age in Ma (Mega-annum)
  uncertainty: number; // Uncertainty in Ma
  sampleDescription: string;
}

// Interface for a stratigraphic unit
export interface StratigraphicUnit {
  id: string;
  name: string; // e.g., "Green River Formation"
  ageRange: {
    minAge: number; // Ma
    maxAge: number; // Ma
    description?: string; // e.g., "Early to Middle Eocene"
  };
  lithology?: LithologyDescriptor;
  thickness?: number; // Meters;
  depositionalEnvironment?: string;
  contactWithLowerUnit?: string;
  contactWithUpperUnit?: string;
}

// Example Usage:
const zir dating: RadiometricDate = {
  method: DatingMethod.Radiometric,
  isotopeSystem: "U-Pb",
  age: 50.2,
  uncertainty: 0.5,
  sampleDescription: "Zircon from felsic ignimbrite, sample ID: ZRB-123"
};

const formation: StratigraphicUnit = {
  id: "SU-456",
  name: "Kimmeridge Clay Formation",
  ageRange: {
    minAge: 157.3,
    maxAge: 152.1,
    description: "Late Jurassic (Kimmeridgian)"
  },
  lithology: {
    name: "Shale",
    category: RockCategory.Sedimentary,
    grainSize: "Fine"
  },
  thickness: 400
};

            

              
                Copy
              
            
          

            
// Interface for a single geochemical assay value
export interface AssayValue {
  element: string; // e.g., "Au", "Ag", "Cu", "Fe2O3"
  value: number;
  unit: string; // e.g., "ppm", "ppb", "%", "g/t"
  detectionLimit?: number; // If applicable
  isBelowDetectionLimit?: boolean;
}

// Interface for a seismic trace attribute
export interface SeismicAttribute {
  name: string; // e.g., "Amplitude", "Frequency", "RMS Amplitude"
  value: number;
  unit: string; // e.g., "Pa", "Hz", "V^2*s"
}

// Interface for a borehole sample point
export interface SamplePoint {
   boreholeId: string;
  depthFrom: number; // Meters
  depthTo: number; // Meters
  lithology?: LithologyDescriptor;
  assays?: AssayValue[];
  seismicAttributes?: SeismicAttribute[];
  photographicReference?: string; // URL to image
}

// Example Usage:
const goldAssay: AssayValue = {
  element: "Au",
  value: 5.2,
  unit: "g/t"
};

const copperAssay: AssayValue = {
  element: "Cu",
  value: 2500,
  unit: "ppm"
};

const sampleFromMagellan: SamplePoint = {
  boreholeId: "BH-XYZ-007",
  depthFrom: 150.5,
  depthTo: 152.0,
  assays: [goldAssay, copperAssay],
  lithology: {
    name: "Sulfide-bearing Andesite",
    category: RockCategory.Igneous,
    primaryMinerals: [
      { mineral: "Plagioclase", percentage: 50 },
      { mineral: "Amphibole", percentage: 30 }
    ],
    secondaryMinerals: [
      { mineral: "Chalcopyrite", percentage: 5 },
      { mineral: "Pyrite", percentage: 2 }
    ]
  }
};

            

              
                Copy
              
            
          

            
// Enum for common geodetic datums
export enum GeodeticDatum {
  WGS84 = "WGS84",
  NAD83 = "NAD83",
  ETRS89 = "ETRS89"
}

// Interface for a geographic coordinate
export interface GeographicCoordinate {
  latitude: number; // Decimal degrees
  longitude: number; // Decimal degrees
  datum: GeodeticDatum;
}

// Enum for common map projections
export enum ProjectionType {
  Mercator = "Mercator",
  UTM = "UTM",
  LambertConformalConic = "LambertConformalConic",
  AlbersEqualArea = "AlbersEqualArea"
}

// Interface for a projected coordinate
export interface ProjectedCoordinate {
  x: number; // Easting
  y: number; // Northing
  projection: ProjectionType;
  datum: GeodeticDatum;
  zone?: number; // For UTM
  centralMeridian?: number; // For other projections
  standardParallel?: number; // For other projections
}

// Example Usage:
const pointInKyoto: GeographicCoordinate = {
  latitude: 35.0116,
  longitude: 135.7681,
  datum: GeodeticDatum.WGS84
};

// Assume a function that converts Geographic to Projected coordinates
function projectWGS84ToUTM(coord: GeographicCoordinate, utmZone: number): ProjectedCoordinate {
  // ... actual projection logic would go here ...
  console.log(`Projecting ${coord.latitude}, ${coord.longitude} to UTM Zone ${utmZone}`);
  return { x: 123456.78, y: 3876543.21, projection: ProjectionType.UTM, datum: GeodeticDatum.WGS84, zone: utmZone };
}

const projectedPoint: ProjectedCoordinate = projectWGS84ToUTM(pointInKyoto, 54); // UTM Zone 54 for Japan

            

              
                Copy
              
            
          

            
// Simplified GeoJSON Feature interface
export interface GeoJsonFeature {
  type: "Feature";
  geometry: {
    type: "Point" | "LineString" | "Polygon" | "MultiPoint" | "MultiLineString" | "MultiPolygon" | "GeometryCollection";
    coordinates: any; // Complex recursive type for coordinates
  };
  properties: { [key: string]: any };
}

// Interface for a geological feature, extending GeoJSON
export interface GeologicalFeature extends GeoJsonFeature {
  properties: {
    name: string;
    type: "Fault" | "StratigraphicBoundary" | "Outcrop" | "MineralDeposit";
    description?: string;
    // Add geological-specific properties here
    associatedLithology?: string;
    faultType?: FaultType;
    ageMa?: number;
    mineralCommodity?: string;
  };
}

// Example Usage:
const faultGeoJson: GeologicalFeature = {
  type: "Feature",
  geometry: {
    type: "LineString",
    coordinates: [
      [139.6917, 35.6895], // Tokyo
      [139.7528, 35.6852]  // Imperial Palace
    ]
  },
  properties: {
    name: "Tokyo Fault Segment A",
    type: "Fault",
    description: "A major thrust fault underlying the metropolitan area.",
    faultType: FaultType.Thrust
  }
};

            

              
                Copy
              
            
          

            
// Interface for a single data point in a time series
export interface TimeSeriesPoint {
  timestamp: Date; // Standard JavaScript Date object
  value: number;
  qualityFlag?: "Good" | "Suspect" | "Bad" | "Estimated";
}

// Interface for a time series dataset
export interface TimeSeriesDataset {
  id: string;
  name: string;
  units: string;
  description?: string;
  data: TimeSeriesPoint[];
  metadata?: { [key: string]: any }; // Additional context like station ID, location, etc.
}

// Example Usage:
const temperatureData: TimeSeriesDataset = {
  id: "temp-tokyo-station-45",
  name: "Daily Average Temperature",
  units: "°C",
  data: [
    { timestamp: new Date("2023-01-01"), value: 5.2 },
    { timestamp: new Date("2023-01-02"), value: 4.8, qualityFlag: "Good" },
    { timestamp: new Date("2023-01-03"), value: 3.9, qualityFlag: "Suspect" },
    // ... more data points
  ],
  metadata: {
    stationId: "45",
    location: { latitude: 35.6895, longitude: 139.6917 }
  }
};

            

              
                Copy
              
            
          

            
// Interface for a grid cell in 3D
export interface GridCell3D {
  xIndex: number;
  yIndex: number;
  zIndex: number;
  // Properties that can vary per cell
  porosity?: number;
  permeability?: number;
  density?: number;
  temperature?: number;
  pressure?: number;
}

// Interface for simulation boundary conditions
export interface BoundaryCondition {
  type: "Dirichlet" | "Neumann" | "Robin";
  value: number; // Or a function for time-varying conditions
  boundaryName: "top" | "bottom" | "north" | "south" | "east" | "west";
}

// Interface for a simulation setup
export interface SimulationSetup {
  name: string;
  modelDescription: string;
  gridDimensions: { nx: number; ny: number; nz: number };
  spatialResolution: { dx: number; dy: number; dz: number }; // Meters
  timeStep: number; // Seconds
  totalSimulationTime: number; // Seconds
  boundaryConditions: BoundaryCondition[];
  initialConditions?: { [key: string]: number | number[] }; // e.g., initial pressure map
  physicsParameters: {
    viscosity?: number;
    thermalConductivity?: number;
    rockCompressibility?: number;
  };
}

// Example Usage:
const reservoirSimulation: SimulationSetup = {
  name: "OilReservoirFlow",
  modelDescription: "Simulates fluid flow in a porous medium.",
  gridDimensions: { nx: 100, ny: 100, nz: 50 },
  spatialResolution: { dx: 10, dy: 10, dz: 5 },
  timeStep: 3600, // 1 hour
  totalSimulationTime: 365 * 24 * 3600, // 1 year
  boundaryConditions: [
    { type: "Neumann", value: 0, boundaryName: "top" },
    { type: "Dirichlet", value: 1000000, boundaryName: "bottom" } // Pascals
  ],
  physicsParameters: {
    viscosity: 0.001, // Pa.s
    thermalConductivity: 2.0 // W/(m.K)
  }
};

            

              
                Copy